home *** CD-ROM | disk | FTP | other *** search
/ Info-Mac 3 / Info_Mac_1994-01.iso / Development / General / SpriteWorld 1.0b3 / Examples / SpriteTest / Application.c < prev    next >
C/C++ Source or Header  |  1993-06-12  |  13KB  |  830 lines
  1. ///--------------------------------------------------------------------------------------
  2. //    Application.c
  3. //
  4. //    Created:    Sunday, April 11, 1993
  5. //    By:        Tony Myles
  6. //
  7. //    Copyright: © 1993 Tony Myles, All rights reserved worldwide.
  8. ///--------------------------------------------------------------------------------------
  9.  
  10.  
  11. #if THINK_C
  12. #ifndef __BDC__
  13. #include <BDC.h>
  14. #endif
  15. #else
  16. #ifndef __PACKAGES__
  17. #include <Packages.h>
  18. #endif
  19. #endif
  20.  
  21. #ifndef __APPLEEVENTS__
  22. #include <AppleEvents.h>
  23. #endif
  24.  
  25. #ifndef __DESK__
  26. #include <Desk.h>
  27. #endif
  28.  
  29. #ifndef __DIALOGS__
  30. #include <Dialogs.h>
  31. #endif
  32.  
  33. #ifndef __DISKINIT__
  34. #include <DiskInit.h>
  35. #endif
  36.  
  37. #ifndef __EPPC__
  38. #include <EPPC.h>
  39. #endif
  40.  
  41. #ifndef __EVENTS__
  42. #include <Events.h>
  43. #endif
  44.  
  45. #ifndef __ERRORS__
  46. #include <Errors.h>
  47. #endif
  48.  
  49. #ifndef __FONTS__
  50. #include <Fonts.h>
  51. #endif
  52.  
  53. #ifndef __GESTALTEQU__
  54. #include <GestaltEqu.h>
  55. #endif
  56.  
  57. #ifndef __MENUS__
  58. #include <Menus.h>
  59. #endif
  60.  
  61. #ifndef __RESOURCES__
  62. #include <Resources.h>
  63. #endif
  64.  
  65. #ifndef __OSEVENTS__
  66. #include <OSEvents.h>
  67. #endif
  68.  
  69. #ifndef __TEXTEDIT__
  70. #include <TextEdit.h>
  71. #endif
  72.  
  73. #ifndef __TRAPS__
  74. #include <Traps.h>
  75. #endif
  76.  
  77. #ifndef __TOOLUTILS__
  78. #include <ToolUtils.h>
  79. #endif
  80.  
  81. #ifndef __WINDOWS__
  82. #include <Windows.h>
  83. #endif
  84.  
  85. #ifndef __SPRITEWORLD__
  86. #include <SpriteWorld.h>
  87. #endif
  88.  
  89. #ifndef __SPRITEWORLDUTILS__
  90. #include <SpriteWorldUtils.h>
  91. #endif
  92.  
  93. #ifndef __APPLICATION__
  94. #include "Application.h"
  95. #endif
  96.  
  97. #ifndef __SPRITETEST__
  98. #include "SpriteTest.h"
  99. #endif
  100.  
  101. #ifndef __ABOUT__
  102. #include "About.h"
  103. #endif
  104.  
  105.  
  106. Boolean gIsRunning = true;
  107. Boolean gInBackGround = false;
  108. Boolean gHasWaitNextEvent = false;
  109. WindowPtr gWindowP = NULL;
  110. SpriteTestPtr gSpriteTestP = NULL;
  111.  
  112.  
  113. void main(void)
  114. {
  115.     OSErr err = noErr;
  116.  
  117.     if (Initialize(kNumberOfMoreMastersCalls))
  118.     {
  119.         if (CheckSystem() && CheckMemory())
  120.         {
  121.             if (HasAppleEvents())
  122.             {
  123.                 err = InstallAppleEventHandlers();
  124.     
  125.                 if (err != noErr)
  126.                 {
  127.                     ErrorAlert(err, kUnknownErrorStringIndex);
  128.                 }
  129.             }
  130.     
  131.             CreateMenuBar();
  132.             CreateWindow();
  133.     
  134.             if (EnterApplication())
  135.             {
  136.                 ServiceEvents();
  137.             }
  138.     
  139.             ExitApplication();
  140.         }
  141.     }
  142.  
  143.     ExitToShell();
  144. }
  145.  
  146.  
  147. Boolean Initialize(
  148.     short numberOfMasters)
  149. {
  150.     OSErr err;
  151.     EventRecord tempEvent;
  152.  
  153.     if (kStackNeeded > StackSpace())
  154.     {
  155.             // new address is heap size + current stack - needed stack
  156.         SetApplLimit((Ptr)((long)GetApplLimit() - kStackNeeded + StackSpace()));
  157.  
  158.         err = MemError();
  159.     }
  160.  
  161.     if (err == noErr)
  162.     {
  163.         MaxApplZone();
  164.  
  165.         while ((err == noErr) && (numberOfMasters--))
  166.         {
  167.             MoreMasters();
  168.  
  169.             err = MemError();
  170.         }
  171.     }
  172.  
  173.     if (err == noErr)
  174.     {
  175.         InitGraf(&qd.thePort);
  176.         InitFonts();
  177.         InitWindows();
  178.         InitMenus();
  179.         TEInit();
  180.         InitDialogs(NULL);
  181.         InitCursor();
  182.         FlushEvents(everyEvent, 0);
  183.  
  184.         (void)EventAvail(everyEvent, &tempEvent);
  185.         (void)EventAvail(everyEvent, &tempEvent);
  186.         (void)EventAvail(everyEvent, &tempEvent);
  187.  
  188.         gHasWaitNextEvent = HasWaitNextEvent();
  189.     }
  190.  
  191.         // if we get an error here, we can’t do jack
  192.         // don’t even TRY to put up an alert
  193.  
  194.     return err == noErr;
  195. }
  196.  
  197.  
  198. Boolean CheckSystem(void)
  199. {
  200.     OSErr    err;
  201.     Boolean isSystemGood = true;
  202.     long    gestaltResult;
  203.  
  204.     err = Gestalt(gestaltTimeMgrVersion, &gestaltResult);
  205.  
  206.     isSystemGood = (err == noErr) && (gestaltResult >= gestaltStandardTimeMgr);
  207.  
  208.     if (!isSystemGood)
  209.     {
  210.         CantRunOnThisMachine();
  211.     }
  212.  
  213.     return isSystemGood;
  214. }
  215.  
  216.  
  217. Boolean CheckMemory(void)
  218. {
  219.     Boolean isEnoughMemory;
  220.     long heapNeeded, heapSize;
  221.     GDHandle mainGDeviceH;
  222.     Rect worldRect;
  223.     short pixelSize;
  224.  
  225.     if (SWHasColorQuickDraw())
  226.     {
  227.         mainGDeviceH = GetMainDevice();
  228.  
  229.         worldRect = (**mainGDeviceH).gdRect;
  230.         pixelSize = (**(**mainGDeviceH).gdPMap).pixelSize;
  231.     }
  232.     else
  233.     {
  234.         worldRect = qd.screenBits.bounds;
  235.         pixelSize = 1;
  236.     }
  237.  
  238.     heapNeeded = 3 * ((((worldRect.right - worldRect.left) *
  239.                             (worldRect.bottom - worldRect.top)) * pixelSize) / 8);
  240.     heapNeeded += 100000;
  241.  
  242.     heapSize = (long)GetApplLimit() - (long)ApplicZone();
  243.  
  244.     isEnoughMemory = (heapSize > heapNeeded);
  245.  
  246.     if (!isEnoughMemory)
  247.     {
  248.         ErrorAlert(memFullErr, kNotEnoughMemoryStringIndex);
  249.     }
  250.  
  251.     return isEnoughMemory;
  252. }
  253.  
  254.  
  255. Boolean HasAppleEvents(void)
  256. {
  257.     Boolean hasAppleEvents;
  258.     OSErr err;
  259.     long gestaltResult;
  260.  
  261.     err = Gestalt(gestaltAppleEventsAttr, &gestaltResult);
  262.  
  263.     if (err == noErr)
  264.     {
  265.         hasAppleEvents = (gestaltResult & (1 << gestaltAppleEventsPresent)) != 0;
  266.     }
  267.     else
  268.     {
  269.         hasAppleEvents = false;
  270.     }
  271.  
  272.     return hasAppleEvents;
  273. }
  274.  
  275.  
  276. OSErr InstallAppleEventHandlers(void)
  277. {
  278.     OSErr err = noErr;
  279.  
  280.     err = AEInstallEventHandler(kCoreEventClass, kAEOpenApplication, HandleOpenApp, 0, false);
  281.  
  282.     if (err == noErr)
  283.     {
  284.         err = AEInstallEventHandler(kCoreEventClass, kAEOpenDocuments, HandleOpenDoc, 0, false);
  285.     }
  286.  
  287.     if (err == noErr)
  288.     {
  289.         err = AEInstallEventHandler(kCoreEventClass, kAEPrintDocuments, HandlePrintDoc, 0, false);
  290.     }
  291.  
  292.     if (err == noErr)
  293.     {
  294.         err = AEInstallEventHandler(kCoreEventClass, kAEQuitApplication, HandleQuit, 0, false);
  295.     }
  296.  
  297.     return err;
  298. }
  299.  
  300.  
  301. void CreateMenuBar(void)
  302. {
  303.     Handle menuBarH;
  304.  
  305.     menuBarH = GetNewMBar(kMenuBarResID);
  306.  
  307.     if (menuBarH != NULL)
  308.     {
  309.         SetMenuBar(menuBarH);
  310.         AddResMenu(GetMHandle(kAppleMenuID), 'DRVR');
  311.         DrawMenuBar();
  312.     }
  313.     else
  314.     {
  315.         CantFindResource();
  316.     }
  317. }
  318.  
  319.  
  320. void CreateWindow(void)
  321. {
  322.     gWindowP = SWHasColorQuickDraw() ?
  323.             GetNewCWindow(kWindowResID, NULL, (WindowPtr)-1L) :
  324.             GetNewWindow(kWindowResID, NULL, (WindowPtr)-1L);
  325.  
  326.     if (gWindowP != NULL)
  327.     {
  328.         SizeWindow(gWindowP, qd.screenBits.bounds.right, qd.screenBits.bounds.bottom, false);
  329.         MoveWindow(gWindowP, 0, 0, false);
  330.     }
  331.     else
  332.     {
  333.         CantFindResource();
  334.     }
  335. }
  336.  
  337.  
  338. Boolean EnterApplication(void)
  339. {
  340.     OSErr    err;
  341.  
  342.     err = SWEnterSpriteWorld();
  343.  
  344.     if (err == noErr)
  345.     {
  346.         err = CreateSpriteTest(&gSpriteTestP, (CWindowPtr)gWindowP);
  347.     }
  348.  
  349.     if (err == noErr)
  350.     {
  351.         ShowWindow(gWindowP);
  352.         UpdateSpriteTest(gSpriteTestP);
  353.         ValidRect(&gWindowP->portRect);
  354.     }
  355.  
  356.     if (err != noErr)
  357.     {
  358.         ErrorAlert(err, kUnknownErrorStringIndex);
  359.     }
  360.  
  361.     return err == noErr;
  362. }
  363.  
  364.  
  365. void ExitApplication(void)
  366. {
  367.     DisposeSpriteTest(gSpriteTestP);
  368.  
  369.     SWExitSpriteWorld();
  370.  
  371.     DisposeWindow(gWindowP);
  372. }
  373.  
  374.  
  375. void ServiceEvents(void)
  376. {
  377.     Boolean haveEvent;
  378.     EventRecord event;
  379.     long sleepTime;
  380.     RgnHandle mouseRgn = gHasWaitNextEvent ? NewRgn() : NULL;
  381.  
  382.     while (gIsRunning)
  383.     {
  384.         if (gHasWaitNextEvent)
  385.         {
  386.             sleepTime = gInBackGround ? kBackGroundSleepTime : kForeGroundSleepTime;
  387.  
  388.             haveEvent = WaitNextEvent(everyEvent, &event, sleepTime, mouseRgn);
  389.         }
  390.         else
  391.         {
  392.             SystemTask();
  393.             haveEvent = GetNextEvent(everyEvent, &event);
  394.         }
  395.  
  396.         if (haveEvent)
  397.         {
  398.             DispatchEvent(&event);
  399.         }
  400.         else
  401.         {
  402.             HandleNullEvent();
  403.         }
  404.     }
  405.  
  406.     if (mouseRgn != NULL)
  407.     {
  408.         DisposeRgn(mouseRgn);
  409.     }
  410. }
  411.  
  412.  
  413. void DispatchEvent(
  414.     EventRecord* event)
  415. {
  416.     switch(event->what)
  417.     {
  418.         case mouseDown:            HandleMouseEvent(event);
  419.         break;
  420.         case mouseUp:
  421.         break;
  422.         case keyUp:
  423.         break;
  424.         case keyDown:
  425.         case autoKey:                HandleKeyEvent((char)(event->message & charCodeMask), event->modifiers);
  426.         break;
  427.         case updateEvt:            HandleUpdateEvent((WindowPtr)event->message);
  428.         break;
  429.         case diskEvt:                HandleDiskEvent(event->message);
  430.         break;
  431.         case activateEvt:            HandleActivateEvent((WindowPtr)event->message);
  432.         break;
  433.         case networkEvt:
  434.         break;
  435.         case driverEvt:
  436.         break;
  437.         case app1Evt:
  438.         break;
  439.         case app2Evt:
  440.         break;
  441.         case app3Evt:
  442.         break;
  443.         case osEvt:                    HandleOSEvent(event->message);
  444.         break;
  445.         case kHighLevelEvent:    AEProcessAppleEvent(event);
  446.         default:
  447.         break;
  448.     }
  449. }
  450.  
  451.  
  452. void HandleMouseEvent(
  453.     EventRecord* event)
  454. {
  455.     WindowPtr whichWindow;
  456.     short partCode;
  457.  
  458.     partCode = FindWindow(event->where, &whichWindow);
  459.  
  460.     switch (partCode)
  461.     {
  462.         case inDesk:        
  463.         break;
  464.         case inMenuBar:
  465.             AdjustSpriteTestMenu(gSpriteTestP, GetMHandle(kSpriteMenuID));
  466.             HandleMenuCommand(MenuSelect(event->where));
  467.             break;
  468.         case inSysWindow:        SystemClick(event, whichWindow);
  469.         break;
  470.         case inContent:
  471.         break;
  472.         case inDrag:
  473.         break;
  474.         case inGrow:
  475.         break;
  476.         case inGoAway:
  477.         break;
  478.         case inZoomIn:
  479.         case inZoomOut:
  480.         break;
  481.         default:            
  482.         break;
  483.     }
  484. }
  485.  
  486.  
  487. void HandleKeyEvent(
  488.     char key,
  489.     short modifiers)
  490. {
  491.     if ((modifiers & cmdKey) != 0)
  492.     {
  493.         AdjustSpriteTestMenu(gSpriteTestP, GetMHandle(kSpriteMenuID));
  494.         HandleMenuCommand(MenuKey(key));
  495.     }
  496.     else
  497.     {
  498.         // do whatever
  499.     }
  500. }
  501.  
  502.  
  503. void HandleUpdateEvent(
  504.     WindowPtr updateWindowP)
  505. {
  506.     if (updateWindowP == gWindowP)
  507.     {
  508.         SetPort(updateWindowP);
  509.         BeginUpdate(updateWindowP);
  510.  
  511.         UpdateSpriteTest(gSpriteTestP);
  512.  
  513.         EndUpdate(updateWindowP);
  514.     }
  515. }
  516.  
  517.  
  518. void HandleActivateEvent(
  519.     WindowPtr updateWindowP)
  520. {
  521. }
  522.  
  523.  
  524. void HandleOSEvent(
  525.     long message)
  526. {
  527.     if ((message >> 24) == suspendResumeMessage)
  528.     {
  529.         if ((message & resumeFlag) != 0)
  530.         {
  531.             gInBackGround = false;
  532.         }
  533.         else
  534.         {
  535.             gInBackGround = true;
  536.         }
  537.     }
  538. }
  539.  
  540.  
  541. void HandleDiskEvent(
  542.     long message)
  543. {
  544.     OSErr err;
  545.     Point dialogLocation = {100, 100};
  546.  
  547.     if ((message & 0xFFFF0000) != noErr)
  548.     {
  549.         err = DIBadMount(dialogLocation, message);
  550.  
  551.         if (err != noErr)
  552.         {
  553.             ErrorAlert(err, kUnknownErrorStringIndex);
  554.         }
  555.     }
  556. }
  557.  
  558.  
  559. void HandleNullEvent(void)
  560. {
  561.     RunSpriteTest(gSpriteTestP);
  562. }
  563.  
  564.  
  565. void HandleMenuCommand(
  566.     long menuItemIdentifier)
  567. {
  568.     short menuIdent = HiWord(menuItemIdentifier);
  569.     short menuItem = LoWord(menuItemIdentifier);
  570.  
  571.     switch (menuIdent)
  572.     {
  573.         case kAppleMenuID:
  574.         {
  575.             HandleAppleMenuCommand(menuItem);
  576.             break;
  577.         }
  578.  
  579.         case kFileMenuID:
  580.         {
  581.             HandleFileMenuCommand(menuItem);
  582.             break;
  583.         }
  584.  
  585.         case kEditMenuID:
  586.         {
  587.             HandleEditMenuCommand(menuItem);
  588.             break;
  589.         }
  590.  
  591.         case kSpriteMenuID:
  592.         {
  593.             HandleSpriteMenuCommand(menuItem);
  594.             break;
  595.         }
  596.     }
  597.  
  598.     HiliteMenu(0);
  599. }
  600.  
  601.  
  602. void HandleAppleMenuCommand(
  603.     short menuItem)
  604. {
  605.     Str255 deskAccName;
  606.  
  607.     switch (menuItem)
  608.     {
  609.         case kAboutItem:
  610.         {
  611.             DisplayAboutBox();
  612.             break;
  613.         }
  614.  
  615.         default:
  616.         {
  617.             GetItem(GetMHandle(kAppleMenuID), menuItem, deskAccName);
  618.             OpenDeskAcc(deskAccName);
  619.             break;
  620.         }
  621.     }
  622. }
  623.  
  624.  
  625. void HandleFileMenuCommand(
  626.     short menuItem)
  627. {
  628.     switch (menuItem)
  629.     {
  630.         case kQuitItem:
  631.         {
  632.             gIsRunning = false;
  633.             break;
  634.         }
  635.     }
  636. }
  637.  
  638.  
  639. void HandleEditMenuCommand(
  640.     short menuItem)
  641. {
  642.     (void)SystemEdit(menuItem);
  643. }
  644.  
  645.  
  646. void HandleSpriteMenuCommand(
  647.     short menuItem)
  648. {
  649.     switch (menuItem)
  650.     {
  651.         case kHideTitleItem:
  652.         {
  653.             HandleSpriteTestTitleCommand(gSpriteTestP);
  654.             break;
  655.         }
  656.  
  657.         case kHideBallsItem:
  658.         {
  659.             HandleBouncingBallsCommand(gSpriteTestP);
  660.             break;
  661.         }
  662.  
  663.         case kCollisionDetectionItem:
  664.         {
  665.             gSpriteTestP->isCommandActive[kCollisionDetectionCommand] =
  666.                     !gSpriteTestP->isCommandActive[kCollisionDetectionCommand];
  667.             break;
  668.         }
  669.  
  670.         case kCopyBitsTestItem:
  671.         {
  672.             CopyBitsSpeedTestCommand(gSpriteTestP);
  673.             break;
  674.         }
  675.  
  676.         case kBlitPixieTestItem:
  677.         {
  678.             BlitPixieSpeedTestCommand(gSpriteTestP);
  679.             break;
  680.         }
  681.  
  682.         case kSpriteTestItem:
  683.         {
  684.             SpriteTestCommand(gSpriteTestP, (CWindowPtr)gWindowP);
  685.             break;
  686.         }
  687.     }
  688. }
  689.  
  690. pascal OSErr HandleOpenApp(
  691.     AppleEvent srcAppleEvent,
  692.     AppleEvent replyAppleEvent,
  693.     long refCon)
  694. {
  695.     return noErr;
  696. }
  697.  
  698.  
  699. pascal OSErr HandleOpenDoc(
  700.     AppleEvent srcAppleEvent,
  701.     AppleEvent replyAppleEvent,
  702.     long refCon)
  703. {
  704.     return errAEEventNotHandled;
  705. }
  706.  
  707.  
  708. pascal OSErr HandlePrintDoc(
  709.     AppleEvent srcAppleEvent,
  710.     AppleEvent replyAppleEvent,
  711.     long refCon)
  712. {
  713.     return errAEEventNotHandled;
  714. }
  715.  
  716.  
  717. pascal OSErr HandleQuit(
  718.     AppleEvent srcAppleEvent,
  719.     AppleEvent replyAppleEvent,
  720.     long refCon)
  721. {
  722.     gIsRunning = false;
  723.  
  724.     return noErr;
  725. }
  726.  
  727.  
  728. void ErrorAlert(
  729.     OSErr err,
  730.     short errorStringIndex)
  731. {
  732.     Str255 messageString, errorString;
  733.  
  734.         // make sure we don't know what this error is...
  735.     if (errorStringIndex == kUnknownErrorStringIndex)
  736.     {
  737.         switch (err)
  738.         {
  739.             case memFullErr:
  740.                 errorStringIndex = kNotEnoughMemoryStringIndex;
  741.                 break;
  742.  
  743.             case resNotFound:
  744.                 errorStringIndex = kCantFindResourceStringIndex;
  745.                 break;
  746.         }
  747.     }
  748.  
  749.     GetIndString(messageString, kErrorStringListResID, errorStringIndex);
  750.  
  751.     if (messageString[0] == 0)
  752.     {
  753.         BlockMove(kSeriousDamageString, messageString, sizeof(kSeriousDamageString));
  754.     }
  755.  
  756.     NumToString(err, errorString);
  757.  
  758.     ParamText(messageString, errorString, "\p", "\p");
  759.  
  760.     (void)StopAlert(kErrorAlertResID, NULL);
  761. }
  762.  
  763.  
  764. void CantFindResource(void)
  765. {
  766.     OSErr err;
  767.     
  768.     err = ResError();
  769.     
  770.     if (err == noErr)
  771.     {
  772.         err = resNotFound;
  773.     }
  774.  
  775.     ErrorAlert(err, kCantFindResourceStringIndex);
  776.  
  777.     ExitToShell();
  778. }
  779.  
  780.  
  781. void CantRunOnThisMachine(void)
  782. {
  783.     (void)StopAlert(kCantRunAlertResID, NULL);
  784. }
  785.  
  786.  
  787. short NumToolboxTraps(void)
  788. {
  789.     return    (NGetTrapAddress(_InitGraf, ToolTrap) == NGetTrapAddress(0xAA6E, ToolTrap))
  790.                 ?    0x0200 :    0x0400;
  791. }
  792.  
  793.  
  794. TrapType GetTrapType(
  795.     short trap)
  796. {
  797.     #define TrapMask 0x0800
  798.  
  799.     return ((trap & TrapMask) != 0) ? ToolTrap : OSTrap;
  800. }
  801.  
  802.  
  803. Boolean TrapAvail(
  804.     short trap)
  805. {
  806.     TrapType    tType;
  807.  
  808.     tType = GetTrapType(trap);
  809.     if (tType == ToolTrap)
  810.     {
  811.         trap = trap & 0x07FF;
  812.     }
  813.  
  814.     if (trap >= NumToolboxTraps())
  815.     {
  816.         trap = _Unimplemented;
  817.     }
  818.  
  819.     return NGetTrapAddress(trap, tType) !=
  820.              NGetTrapAddress(_Unimplemented, ToolTrap);
  821. }
  822.  
  823.  
  824. Boolean HasWaitNextEvent(void)
  825. {
  826.     return TrapAvail(_WaitNextEvent);
  827. }
  828.  
  829.  
  830.